<template>
	<view class="container">
		<scroll-view scroll-y="true">
			<!-- 顶部标题栏 -->
			<view class="top-bar">
				<text class="title">工作台</text>
				<view class="user-info" @click="navigateToProfile">
					<!-- 显示头像与昵称（如果有），否则展示默认角色 -->
					<image v-if="currentUser.avatarUrl" :src="http.baseUrl + currentUser.avatarUrl" class="user-avatar"
		mode="widthFix" />
					<view v-else class="default-avatar">
						<text
							class="default-avatar-text">{{ currentUser.nickName ? currentUser.nickName[0] : '游' }}</text>
					</view>
					<text class="user-role">{{currentUser.nickName}} {{ currentUser.role }}</text>
					<image src="" class="user-arrow" mode="widthFix" />
				</view>
			</view>

			<!-- 增强数据卡片区 -->
			<view class="cards-container">
				<view class="card" hover-class="card-hover" v-for="(stat, index) in statistics" :key="index"
					@click="handleCardClick(stat.type)">
					<text class="card-title">{{ stat.title }}</text>
					<text class="card-value">{{ stat.value }}</text>
					<view class="card-progress" v-if="stat.progress">
						<progress :percent="stat.progress" stroke-width="6" />
					</view>
					<text class="card-trend" :class="{ down: stat.trend < 0 }">
						{{ stat.trend > 0 ? '↑' : '↓' }} {{ Math.abs(stat.trend) }} 较昨日
					</text>
				</view>
			</view>



			<!-- 今日团期区 -->
			<view class="task-section">
				<view class="section-header">
					<text class="section-title">今日团期</text>
					<text class="section-count">({{tasks.length}})</text>
				</view>

				<view class="task-groups-container">
					<scroll-view scroll-y="true" class="task-scroll">
						<view class="task-list">
							<!-- 有数据时显示团期列表 -->
							<template v-if="tasks && tasks.length > 0">
								<view class="task-item" hover-class="task-hover" v-for="(task, index) in tasks"
									:key="task.id || index" @click="handleTaskAction(task.id, task.status)">
									<view class="task-info">
										<view class="task-icon-wrapper">
											<text class="task-order">{{index + 1}}</text>
										</view>
										<view class="task-text">
											<text class="task-name">{{task.groupName}}</text>
											<text class="task-detail">{{task.capacity}}人 •
												{{task.location}}</text>
										</view>
									</view>
								</view>
							</template>
							<!-- 无数据时显示空状态 -->
							<view v-else class="empty-state">
								<image src="/static/index/group-icon.png" class="empty-icon" mode="widthFix" />
								<text class="empty-text">暂无今日团期</text>
								<text class="empty-subtext">点击「新建团队」开始安排行程</text>
							</view>
						</view>
					</scroll-view>
				</view>
			</view>

			<!-- 优化功能按钮区 -->
			<view class="func-section">
				<view class="section-header">
					<text class="section-title">快捷操作</text>
				</view>

				<view class="func-grid">
					<view class="func-item" hover-class="func-hover" v-for="(func, index) in functions" :key="index"
						@click="navigateToFunction(func.path)">
						<view class="func-icon-wrapper" :style="{backgroundColor: func.color}">
							<image :src="func.icon" class="func-icon" mode="widthFix" />
						</view>
						<text class="func-text">{{ func.name }}</text>
						<!-- <text class="func-badge" v-if="func.badge">{{func.badge}}</text> -->
					</view>
				</view>
			</view>



			<!-- 最新通知区 -->
			<view class="notice-section">
				<view class="section-header">
					<text class="section-title">最新通知</text>
					<text class="more-link" @click="navigateToAllNotices">查看全部</text>
				</view>

				<view class="notice-list">
					<view class="notice-item" hover-class="notice-hover" v-for="(notice, index) in notices" :key="index"
						@click="navigateToNoticeDetail(notice.id)">
						<view class="notice-content">
							<text class="notice-title">{{ notice.title }}</text>
							<text class="notice-time">{{ formatTime(notice.time) }}</text>
						</view>
					</view>
				</view>
			</view>

		</scroll-view>
	</view>
</template>

<script>
	// 导入auth.js中的方法
import {
	checkLogin,
	getUser,
	isLogin
} from '@/https/auth.js'

// 导入统计接口模块
import statisticsApi from '@/https/statistics.js'

// 导入http模块
import http from '@/https/http.js'

	export default {
		// 响应式数据
		data() {
			return {
				// 当前用户信息
				currentUser: {
					role: ' 您好！',
					id: 'guide001',
					nickName: '',
					avatarUrl: ''
				},
				// 统计数据
				statistics: [{
						title: '今日带团数',
						value: 0,
						trend: 0,
						type: 'team',
						progress: 0
					},
					{
						title: '今日订单数',
						value: 0,
						trend: 0,
						type: 'task',
						progress: 0
					},
					{
						title: '今日游客数',
						value: 0,
						trend: 0,
						type: 'guest',
						progress: 0
					}
				],
				// 今日团期数据
				tasks: [],
				// 功能导航数据
				functions: [{
						name: '新建团队',
						icon: '/static/index/addroup.png',
						path: '/pages/groups/addgroup',
						color: '#FFEBEE',
						badge: 0
					},
					{
						name: '我的团期',
						icon: '/static/index/group-icon.png',
						path: '/pages/groups/groupslist',
						color: '#E3F2FD',
						badge: 0
					},
					{
						name: '车辆管理',
						icon: '/static/index/car-icon.png',
						path: '/pages/cars/carlist',
						color: '#E8F5E9',
						badge: 0
					},
					{
						name: '行程管理',
						icon: '/static/index/itinerary-icon.png',
						path: '/pages/mine/itinerarylist',
						color: '#F1F8E9',
						badge: 0
					},
					{
						name: '工作日志',
						icon: '/static/index/log-icon.png',
						path: '/pages/work-log',
						color: '#F3E5F5',
						badge: 0
					},
					{
						name: '资源调度中心',
						icon: '/static/index/zydd.png',
						path: '/pages/resourceCalendar/resourceCalendar',
						color: '#E0F7FA',
						badge: 0
					}
				],
				// 通知数据
				notices: [],
				// 定时获取数据的定时器
				dataRefreshTimer: null
			}
		},

		// 生命周期钩子
		onLoad() {
			// 页面加载时初始化
			this.initPage()
		},

		onShow() {
			// 页面显示时执行
			this.handlePageShow()
		},

		onHide() {
			// 页面隐藏时停止定时数据刷新
			this.stopPeriodicDataRefresh()
		},

		onUnload() {
			// 页面卸载时停止定时数据刷新并清理事件监听
			this.stopPeriodicDataRefresh()
			try {
				if (typeof uni !== 'undefined' && uni.$off) {
					uni.$off('user:updated')
				}
			} catch (e) {
				// ignore
			}
		},

		// 计算属性
	computed: {
		// 提供 http 对象给模板使用
		http() {
			return http
		}
	},

	// 方法
	methods: {
			// 初始化页面
			async initPage() {
				try {
					// 先检查登录状态，确保只调用一次Authorization
					const loggedIn = await checkLogin();
					if (loggedIn) {
						// 更新用户信息
						const user = getUser();
						if (user) {
							if (user.nickName) this.currentUser.nickName = user.nickName;
							if (user.avatarUrl) this.currentUser.avatarUrl = user.avatarUrl;
							if (user.role) this.currentUser.role = user.role;
							
							// 初始化实时数据 - 只在登录成功后执行，添加1秒延迟
							await new Promise(resolve => setTimeout(resolve, 1000));
							await this.fetchRealTimeData();
							// 首次加载时启动定时获取数据 - 只在登录成功后执行
							this.startPeriodicDataRefresh();
						}


					}
				} catch (e) {
					console.error('初始化数据失败:', e);
				}

				// 监听用户信息更新事件
				this.setupUserInfoListener();
			},

			// 处理页面显示
			handlePageShow() {
				// 从存储中获取最新用户信息
				const user = getUser()
				if (user) {
					if (user.nickName) this.currentUser.nickName = user.nickName
					if (user.avatarUrl) this.currentUser.avatarUrl = user.avatarUrl
					if (user.role) this.currentUser.role = user.role
				}
				// 不再在每次页面显示时重新获取数据，避免重复请求
				// 数据已在initPage()中获取，并通过定时刷新保持最新
			},

			// 更新用户信息（简化版本，不再调用checkLogin）
			updateUserInfo() {
				try {
					const user = getUser()
					if (user) {
						if (user.nickName) this.currentUser.nickName = user.nickName
						if (user.avatarUrl) this.currentUser.avatarUrl = user.avatarUrl
						if (user.role) this.currentUser.role = user.role
					}
				} catch (e) {
					// ignore error
				}
			},

			// 设置用户信息监听器
			setupUserInfoListener() {
				try {
					if (typeof uni !== 'undefined' && uni.$on) {
						uni.$on('user:updated', (newUser) => {
							try {
								if (newUser && newUser.nickName) this.currentUser.nickName = newUser.nickName
								if (newUser && newUser.avatarUrl) this.currentUser.avatarUrl = newUser.avatarUrl
							} catch (e) {
								// ignore
							}
						})
					}
				} catch (e) {
					// ignore
				}
			},

			// 启动定时获取数据
			startPeriodicDataRefresh() {
				const refreshInterval = 30000

				if (this.dataRefreshTimer) {
					clearInterval(this.dataRefreshTimer)
				}

				this.dataRefreshTimer = setInterval(() => {
					this.fetchRealTimeData()
				}, refreshInterval)

				console.log(`定时数据刷新已启动，每${refreshInterval/1000}秒更新一次`)
			},

			// 停止定时获取数据
			stopPeriodicDataRefresh() {
				if (this.dataRefreshTimer) {
					clearInterval(this.dataRefreshTimer)
					this.dataRefreshTimer = null
					console.log('定时数据刷新已停止')
				}
			},

			// 获取统计数据（移除重复的登录检查）
			async fetchStatisticsData() {
				try {
					// 使用统计接口模块获取数据
					const stats = await statisticsApi.getAllStatistics();
					this.statistics = stats;

					console.log('获取统计数据成功');
					return true;
				} catch (error) {
					console.error('获取统计数据失败:', error);
					// 如果是401未授权错误，可以尝试重新登录
					if (error.response && error.response.status === 401) {
						console.log('未授权，尝试重新登录...');
						const loggedIn = await checkLogin();
						if (loggedIn) {
							// 重新获取数据
							const retryStats = await statisticsApi.getAllStatistics();
							this.statistics = retryStats;
							return true;
						}
					}
					return false;
				}
			},

			// 获取实时数据
			async fetchRealTimeData() {
				try {
					// 从接口获取统计数据
					await this.fetchStatisticsData();

					// 从接口获取今日团期数据
					const tourGroups = await statisticsApi.getTodayTourGroups();

					// 格式化团期数据为组件需要的格式
					this.tasks = (tourGroups || []).map((group, index) => ({
						id: group.id,
						groupName: group.groupName || '未命名团队',
						capacity: group.capacity,
						time: this.formatTourGroupTime(group.startDate, group.endDate),
						location: group.itineraryName || '未知行程',
						status: this.mapTourGroupStatus(group.status)
					}));

					// 模拟数据 - 只有一条今天的系统上线通知
					const mockData = [{
						id: 'notify-001',
						title: '系统上线通知',
						brief: '新系统已正式上线，带来全新的用户体验和功能优化',
						// 使用iOS兼容的ISO格式时间，设置为今天
						time: new Date().toISOString()
					}];
					this.notices = mockData;

					console.log('定时获取数据成功');
					return true;
				} catch (error) {
					console.error('获取数据失败:', error);
					return false;
				}
			},

			// 卡片点击处理
			handleCardClick(type) {
				const routes = {
					team: '/pages/groups/groupslist',
					task: '/pages/task/list',
					guest: '/pages/guest/list'
				}
				try {
					const route = routes[type]
					if (route) {
						// 判断是否为tabbar页面
						if (route === '/pages/groups/groupslist') {
							uni.switchTab({
								url: route
							});
						} else {
							uni.navigateTo({
								url: route
							});
						}
					} else {
						console.warn('未知的卡片类型:', type)
					}
				} catch (e) {
					console.error('卡片点击导航失败:', e)
				}
			},

			// 处理团期按钮点击
			handleTaskAction(taskId) {
				try {
					// 直接跳转到团期详情页
					uni.navigateTo({
						url: `/pages/groups/tourGroupDetail?groupId=${taskId}`
					});
				} catch (e) {
					console.error('跳转失败:', e);
				}
			},

			// 导航到功能页面
			navigateToFunction(path) {
				try {
					if (path) {
						// 特殊处理工作日志功能
						if (path === '/pages/work-log') {
							uni.showToast({
								title: '功能完善中',
								icon: 'none',
								duration: 2000
							});
							return;
						}

						// 判断是否为tabbar页面
						if (path === '/pages/groups/groupslist') {
							uni.switchTab({
								url: path
							});
						} else {
							uni.navigateTo({
								url: path
							});
						}
					} else {
						console.warn('导航路径为空');
					}
				} catch (e) {
					console.error('导航失败:', e);
				}
			},

			// 导航到个人资料页
			navigateToProfile() {
				try {
					uni.navigateTo({
						url: '/pages/mine/profile'
					});
				} catch (e) {
					console.error('导航到个人资料页失败:', e);
				}
			},

			// 导航到所有通知页面
			navigateToAllNotices() {
				try {
					uni.navigateTo({
						url: '/pages/message/message'
					});
				} catch (e) {
					console.error('导航到通知页面失败:', e);
				}
			},

			// 导航到通知详情
			navigateToNoticeDetail(noticeId) {
				try {
					uni.navigateTo({
						url: `/pages/message/notificationDetail?id=${noticeId}`
					});
				} catch (e) {
					console.error('导航到通知详情失败:', e);
				}
			},

			// 格式化团期时间
			formatTourGroupTime(startDate, endDate) {
				try {
					if (!startDate) return '';

					// 处理日期字符串，确保兼容 iOS 支持的格式
					// iOS 支持的格式: "yyyy/MM/dd"、"yyyy/MM/dd HH:mm:ss"、"yyyy-MM-dd"、"yyyy-MM-ddTHH:mm:ss"、"yyyy-MM-ddTHH:mm:ss+HH:mm"
					const normalizeDateStr = (dateStr) => {
						let normalized = dateStr;
						// 如果日期字符串包含空格分隔符，将其替换为 T 以符合 ISO 格式
						if (normalized && !normalized.includes('/') && !normalized.includes('T') && normalized
							.includes(' ')) {
							const parts = normalized.split(' ');
							if (parts.length >= 2) {
								normalized = `${parts[0]}T${parts[1]}`;
							}
						}
						return normalized;
					};

					const startNormalized = normalizeDateStr(startDate);
					let start = new Date(startNormalized);

					// 如果第一次解析失败，尝试将 yyyy-MM-dd 格式转换为 yyyy/MM/dd 格式
					if (isNaN(start.getTime()) && startNormalized.includes('-')) {
						const dateParts = startNormalized.split('T')[0] || startNormalized.split(' ')[0];
						if (dateParts) {
							const slashFormat = dateParts.replace(/-/g, '/');
							const timePart = startNormalized.includes('T') ?
								startNormalized.split('T')[1] :
								(startNormalized.split(' ')[1] || '');
							const newFormat = timePart ? `${slashFormat}T${timePart}` : slashFormat;
							start = new Date(newFormat);
						}
					}

					if (isNaN(start.getTime())) return '';

					// 提取时分
					const startTime = start.toLocaleTimeString('zh-CN', {
						hour: '2-digit',
						minute: '2-digit',
						hour12: false
					});

					if (!endDate) return startTime;

					const endNormalized = normalizeDateStr(endDate);
					let end = new Date(endNormalized);

					// 同样对结束日期进行格式处理
					if (isNaN(end.getTime()) && endNormalized.includes('-')) {
						const dateParts = endNormalized.split('T')[0] || endNormalized.split(' ')[0];
						if (dateParts) {
							const slashFormat = dateParts.replace(/-/g, '/');
							const timePart = endNormalized.includes('T') ?
								endNormalized.split('T')[1] :
								(endNormalized.split(' ')[1] || '');
							const newFormat = timePart ? `${slashFormat}T${timePart}` : slashFormat;
							end = new Date(newFormat);
						}
					}

					if (isNaN(end.getTime())) return startTime;

					const endTime = end.toLocaleTimeString('zh-CN', {
						hour: '2-digit',
						minute: '2-digit',
						hour12: false
					});

					return `${startTime}-${endTime}`;
				} catch (error) {
					console.error('格式化团期时间失败:', error);
					return '';
				}
			},

			// 映射团期状态
			mapTourGroupStatus(status) {
				const statusMap = {
					0: 'pending',
					1: 'preparing',
					2: 'completed'
				};
				return statusMap[status] || 'pending';
			},

			// 格式化时间显示
			formatTime(timeStr) {
				try {
					// 参数校验
					if (!timeStr || typeof timeStr !== 'string') {
						return '';
					}

					// 处理日期字符串，确保兼容 iOS 支持的格式
					// iOS 支持的格式: "yyyy/MM/dd"、"yyyy/MM/dd HH:mm:ss"、"yyyy-MM-dd"、"yyyy-MM-ddTHH:mm:ss"、"yyyy-MM-ddTHH:mm:ss+HH:mm"
					let normalizedDateStr = timeStr;

					// 尝试标准化日期格式，确保在 iOS 上能正确解析
					// 检查是否为标准格式，不是则尝试转换
					if (!normalizedDateStr.includes('/') && !normalizedDateStr.includes('T')) {
						// 如果包含空格但不是 T 分隔的 ISO 格式，转换为 ISO 格式
						if (normalizedDateStr.includes(' ')) {
							const parts = normalizedDateStr.split(' ');
							if (parts.length >= 2) {
								normalizedDateStr = `${parts[0]}T${parts[1]}`;
							}
						}
					}

					const now = new Date();
					const noticeTime = new Date(normalizedDateStr);

					// 检查日期是否有效
					if (isNaN(noticeTime.getTime())) {
						// 如果第一次解析失败，尝试其他格式转换
						if (normalizedDateStr.includes('-')) {
							// 尝试将 yyyy-MM-dd 格式转换为 yyyy/MM/dd 格式
							const dateParts = normalizedDateStr.split(' ')[0];
							if (dateParts) {
								const slashFormat = dateParts.replace(/-/g, '/');
								const timePart = normalizedDateStr.split(' ')[1] || '';
								const newFormat = timePart ? `${slashFormat} ${timePart}` : slashFormat;
								const retryDate = new Date(newFormat);
								if (!isNaN(retryDate.getTime())) {
									return this.formatTime(newFormat);
								}
							}
						}
						return '';
					}

					// 计算时间差（小时）
					const hoursDiff = Math.floor((now - noticeTime) / (1000 * 60 * 60));

					if (hoursDiff < 24) {
						// 今天的时间，显示小时:分钟
						const timePart = normalizedDateStr.includes('T') ?
							normalizedDateStr.split('T')[1].substring(0, 5) :
							(normalizedDateStr.split(' ')[1] || '').substring(0, 5);
						return timePart || '';
					} else if (hoursDiff < 48) {
						// 昨天
						return '昨天';
					} else if (now.getMonth() === noticeTime.getMonth() && now.getFullYear() === noticeTime
					.getFullYear()) {
						// 本月，显示日期
						return `${noticeTime.getDate()}日`;
					} else {
						// 其他情况，显示月-日
						return `${noticeTime.getMonth() + 1}-${noticeTime.getDate()}`;
					}
				} catch (e) {
					console.error('时间格式化失败:', e);
					return '';
				}
			}
		}
	}
</script>

<style scoped>
	@import './index.css';
</style>